JDK8新特性

Lambda表达式

1. lambda只适用于方法参数列表是函数式接口的情况，函数式接口即接口中有且仅有一个抽象方法的接口【lambda表达式相当于对函数式接口抽象方法的重写】

2. 老的匿名内部类编译以后的字节码文件，发现匿名内部类实际上编译会生成实现对应接口的一个新的类，类的名称为接口名$1

   使用了Lambda后XJad反编译工具无法反编译 ，可以使用jdk自带的工具javap对使用了lambda的类的字节码文件进行反汇编，使用方法是在DOS命令行输入javap -c -p 文件名.class

3. Lambda表达式会在当前类中生成一个名为lambda$上级方法名如main$0的私有静态方法，lambda表达式中的代码会放在这个新增的方法的方法体中，在运行的时候会在方法中生成一个名为lambda表达式所在的类$$Lambda$1的匿名内部类并重写其中的抽象方法，重写方法的时候会在重写方法中调用lambda表达式中生成的私有静态方法lambda$上级方法名如main$0，即lambda表达式会生成匿名内部类和lambda表达式中写入方法对应的静态方法

   运行时生成的类可以通过命令java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.类名将运行时生成的内部类class码输出到一个文件中

   lambda表达式就是对函数式接口的实现并且重写其中的抽象方法

使用条件

1. 方法参数或者局部变量的类型必须是函数式接口才能使用Lambda表达式

   其他参数类型或者参数类型是抽象类都不能使用Lambda表达式

   局部变量单独定义时也可以定义成匿名内部类的形式，这种情况也可以把匿名内部类写成Lambda表达式的结构

   函数式接口：有且只有一个抽象方法的接口，接口上使用注解@FunctionalInterface能够检测接口中是否只含有一个抽象方法

   Flyable f=()->{
       System.out.println("i can fly")
   }
   

2. Lambda表达式和匿名内部类使用上的区别

   • 匿名内部类实现的可以是类、抽象类、接口；Lambda表达式需要的类型必须是函数式接口

     • 匿名内部类实例

       Person是现存的一个类，new Person(){}的意思是创建一个匿名内部类继承Person类，并实例化成一个对象，抽象类中没有抽象方法可以不重写，有抽象方法需要重写

       xxxxxxxxxx
       public static void test(){
           new Person(){
               
           }   
       }
       

   • 匿名内部类实现的类、抽象类、接口中抽象方法的数量随意；Lambda表达式实现的只能是函数式接口

   • 匿名内部类在编译后生成单独的class，Lambda表达式在程序运行时动态生成匿名内部类

      

表达式格式

1. 标准格式

   参数列表是参数类型 参数值,参数类型 参数值,...，函数不需要参数只写括号

   lambda表达式是对函数式接口中的抽象方法的视线，用在方法需要函数式接口实例的情况下，直接写Lambda表达式相当于写了实现了函数式接口并创建了一个匿名内部类并实现了抽象方法，该实例可以在方法中执行实例对应的抽象方法

   箭头的作用是分割参数和方法体

   【语法】

   xxxxxxxxxx
   (参数列表)->{
       方法体
   }
   

   【实例】

   xxxxxxxxxx
   (int a,String b)->{
       return new Persion(a,b);
   }
   

2. 省略格式

   • 参数列表的参数类型可以省略

     xxxxxxxxxx
     (a,b)->{
         return new Persion(a,b);
     }
     

   • 如果参数列表只有一个参数，参数类型和括号都可以省略

     xxxxxxxxxx
     a->{
         return new Persion(a);
     }
     

   • 如果大括号内有且只有一个语句，可以同时省略大括号、return和语句分号

     以上省略大括号、return和语句分号三个部分必须同时省略

     xxxxxxxxxx
     a->new Persion(a)
     

      

常用内置函数式接口

内置函数式接口主要在java.util.function包下

1. 方法声明时可以直接对未实现的抽象方法进行调用和传参

   xxxxxxxxxx
   public class Test01 {
       public static void main(String[] args) {
           test((a,b)->a+b);
       }
       public static void test(Operation op){
           //可以对未实现的抽象方法进行调用和传参
           int sum = op.getSum(1, 2);
           System.out.println(sum);
       }
   }
   interface Operation{
       public abstract int getSum(int a,int b);
   }
   

2. 常用的内置函数式接口

   • Supplier接口

     供给型接口，不给参数但是返回返回值的接口，可以对当前方法括号外的局部变量或者成员变量进行操作

     xxxxxxxxxx
     @FunctionalInterface
     public interface Supplier<T> {
         public abstract T get();
     }
     

     • 应用举例

       打断点查看执行过程会发现先跳到printMax方法中执行supplier.get()前的方法，执行到supplier.get()方法才会跳到Lambda表达式中去执行Lambda表达式的代码

       xxxxxxxxxx
       public class Test02 {
           //使用函数式接口找出数组中最大的元素，感觉这种写法很容易写成脱了裤子放屁的感觉
           public static void main(String[] args) {
               int[] arr={11,99,77,88,22};
               printMax(()->{
                   Arrays.sort(arr);
                   return arr[arr.length-1];
               });
           }
           //声明函数式接口时Supplier<Integer>规定了函数式接口的返回值的类型为Integer
           public static void printMax(Supplier<Integer> supplier){
               Integer max = supplier.get();
               System.out.println("最大的数:"+max);
           }
       }
       

   • Consumer接口

     消费型接口，需要参数，但是没有返回值

     只需要使用传入的参数但是不用返回返回值，比如对数组排序，将字符串转换成大写或者小写

     ​x
     @FunctionalInterface
     public interface Consumer<T> {
     
         void accept(T t);
     
         default Consumer<T> andThen(Consumer<? super T> after) {
             Objects.requireNonNull(after);
             //这里完整写法是return Consumer<T> (T t) -> { accept(t); after.accept(t); }，实际上是返回一个Consumer<T>类型的匿名内部类，相当于用Lambda表达式重写了一个自定义Consumer<T>的实现类，并实现了其中的accept方法，但是特别注意，第一个accept(t)在Lambda表达式的底层是写在匿名内部类c1的实现类中的静态方法[因为通过c1调用的andThen方法]，这个accept方法是写在该静态方法中的，调用的时候自然是调用c1实例对应的accept方法，即c1实例用lambda表达式实现的方法，然后再自然执行c2.accept(t)方法
             return (T t) -> { accept(t); after.accept(t); };
         }
     }
     

     • 应用举例

       xxxxxxxxxx
       public class Test03 {
           public static void main(String[] args) {
               String str="Hello World!";
               printInCases(s->System.out.println(s.toUpperCase()),
                       s->System.out.println(s.toLowerCase()),
                       str);
           }
           //引用同一个函数式接口两次实现分别对字符串进行全体大写处理和全体小写处理，并通过andThen方法实现两个accept方法的调用
           public static void printInCases(Consumer<String> c1,Consumer<String> c2,String str){
               //c1.accept(str);
               //c2.accept(str);
               c1.andThen(c2).accept(str);
           }
       }
       

   • Function接口

     传入一个参数，经过加工以后返回另一个数据

     这个地方结合之前学的super和泛型好好看一下，实际课堂只讲了apply和andThen，andThen的逻辑和Consumer是一样的

     xxxxxxxxxx
     @FunctionalInterface
     public interface Function<T, R> {
     
         R apply(T t);
         
         //形参中使用了泛型需要在方法名之前进行声明，Function<V, R>是一种声明方式，<V>也是一种声明方式，疑问，为啥Function<V, R>声明了还要单独声明一次<V>
         default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
             Objects.requireNonNull(before);
             return (V v) -> apply(before.apply(v));
         }
     
         default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
             Objects.requireNonNull(after);
             return (T t) -> after.apply(apply(t));
         }
     
         static <T> Function<T, T> identity() {
             return t -> t;
         }
     }
     

     • 应用实例

       xxxxxxxxxx
       public class Test04 {
           //将字符串转成数字，然后数字乘以5
           public static void main(String[] args) {
               String str="7";
               getNumber(strData->Integer.parseInt(strData),intData->5*intData,str);
           }
           //Function<String,Integer>表示apply方法需要String类型参数，返回Integer类型的参数
           public static void getNumber(Function<String,Integer> f1,Function<Integer,Integer> f2,String str){
               //Integer count = f1.apply(str);
               //Integer result = f2.apply(count);
               Integer result = f1.andThen(f2).apply(str);
               System.out.println("最终结果:"+result);
           }
       }
       
       

   • Predicate接口

     传入一个数据，根据逻辑对参数进行判断，返回true或者false；判断型接口

     xxxxxxxxxx
     @FunctionalInterface
     public interface Predicate<T> {
     
         boolean test(T t);
     
         //多个判断同时满足就返回true
         default Predicate<T> and(Predicate<? super T> other) {
             Objects.requireNonNull(other);
             return (t) -> test(t) && other.test(t);
         }
         
         //判断一个字符串不满足某个判断就返回true
         default Predicate<T> negate() {
             return (t) -> !test(t);
         }
     
         //只要满足多个条件中的一个就返回true
         default Predicate<T> or(Predicate<? super T> other) {
             Objects.requireNonNull(other);
             return (t) -> test(t) || other.test(t);
         }
         
         static <T> Predicate<T> isEqual(Object targetRef) {
             return (null == targetRef)
                     ? Objects::isNull
                     : object -> targetRef.equals(object);
         }
     
         @SuppressWarnings("unchecked")
         static <T> Predicate<T> not(Predicate<? super T> target) {
             Objects.requireNonNull(target);
             return (Predicate<T>)target.negate();
         }
     }
     
     

     • 应用实例

       xxxxxxxxxx
       public class Test05 {
           //判断字符串中是否包含H字符和W字符
           //以及用Predicate中的API实现多种判断组合
           public static void main(String[] args) {
               String str="Hello World!";
               //str.contains("W")区分大小写
               test(data->data.contains("W"),data->data.contains("H"),str);
           }
           public static void test(Predicate<String> p1,Predicate<String> p2,String str){
               //boolean containW = p1.test(str);
               //boolean containH = p2.test(str);
               //if(containW && containH){
               //    System.out.println("同时包含W和H");
               //}else if (containW){
               //    System.out.println("包含W");
               //}else if(containH){
               //    System.out.println("包含H");
               //}else{
               //    System.out.println("都不包含");
               //}
               boolean test = p1.and(p2).test(str);
               System.out.println(test?"同时包含W和H":"不同时包含W和H");
               boolean test1 = p1.or(p2).test(str);
               System.out.println(test1?"至少包含W和H中的一个":"两个字符都不包含");
               boolean test2 = p1.negate().test(str);
               System.out.println(test2?"不包含W字符":"包含字符");
           }
       }
       

方法引用

lambda表达式仍然可能存在冗余的场景【lambda表达式的方法体直接调用的现成的方法体，显得比较冗余】，结合方法引用可以进一步的简化Lambda表达式

1. 方法引用在Lambda表达式中的实例

   • 方法引用的方法的参数列表需要和函数式接口的抽象方法的参数列表保持一致

   • 被引用方法与抽象方法需要有相同类型的返回值

     以上两个条件不满足编译就会报错

   xxxxxxxxxx
   public class Test06 {
       public static void main(String[] args) {
           //冗余写法
           printSum(()->{
               int[] arr={1,2,3,4,5,6};
               int sum=0;
               for (int data: arr) {
                   sum+=data;
               }
               return sum;
           });
   
           //方法引用,传参需要在printSum方法中传递，如果抽象方法需要使用参数对抽象方法的调用处传递参数给抽象方法
           // 方法引用是不能传递参数的，因为实现抽象方法只需要知晓参数类型和参数个数，不需要知道具体参数，
           // 同时就限定了函数式接口抽象方法的参数列表应该和方法引用保持一致
           // 这种方式限制死了变量要通过外层函数printSum来传递，方法引用的参数列表需要和函数式接口的抽象方法的参数列表保持一致
           // 同时也限制死了被引用方法与抽象方法需要有相同类型的返回值
           //printSum(Test06::getSum);
       }
       
       public static Integer getSum(){
           int[] arr={1,2,3,4,5,6};
           int sum=0;
           for (int data: arr) {
               sum+=data;
           }
           return sum;
       }
       private static void printSum(Supplier<Integer> supplier){
           //参数引用传递参数必须通过printSum函数将从主函数传递来的参数通过下面对抽象方法的调用的同时传递参数给抽象方法
           System.out.println("数组的和为:"+supplier.get());
       }
   }
   

2. 常见方法引用的方式

   除去对静态方法的方法引用外还有多种其他方法引用方式，列举如下

   • instanceName::methodName 对象::实例方法名

     • 实例

       xxxxxxxxxx
       //非maven项目引入junit依赖需要在本地仓库找到junit.junit-4.12和org.hamcrest.hamcrest-core-1.3,同时导入才不会报错
       //同时需要添加测试目录才能生效
       @Test
       public void test(){
           Date now=new Date();
           //冗余写法
           //Supplier<Long> supplier=()-> now.getTime();
           //对实例方法进行方法引用
           Supplier<Long> supplier=now::getTime;
       
           System.out.println("当前时间毫秒数:"+supplier.get());
       }
       

   • ClassName::staticMethodName 类名::静态方法

     • 实例

       xxxxxxxxxx
       //类名::静态方法
       @Test
       public void test02(){
           //冗余写法
           Supplier<Long> supplier=()->System.currentTimeMillis();
           //对静态方法进行方法引用
           //Supplier<Long> supplier=System::currentTimeMillis;
           System.out.println("当前时间毫秒数~"+supplier.get());
       }
       

   • ClassName::methodName 类名::实例方法名

     平常使用的时候，类名是无法直接调用实例方法的，Lambda表达式对这种调用方式进行了特殊处理，使用类名::实例方法名进行方法引用时在方法调用的时候会自动将第一个参数作为方法的调用者，即本质上还是通过对象去调用的实例方法，调用时后续参数才是参数列表的内容，泛型对应第一个是对象的类型、参数列表、返回值类型

     疑问：函数式接口中的抽象方法能被重载吗

     • 实例

       xxxxxxxxxx
       //类名::实例方法
       @Test
       public void test03(){
           //冗余写法
           //使用Function接口实现，不知道为什么要举BiFunction的例子，感觉是用BiFunction来扩展需要传参的方式,这里我理解成
           //接口中已经限制了抽象方法的参数个数，自定义函数式接口也需要规定泛型和抽象方法的参数个数，因此参数个数不同或者参数列表
           //   不同就需要使用不同的函数式接口
           //感觉像类名对对应接口专门进行了处理
           //Function<String,Integer> f1=(str)->str.length();
           //Integer strLength = f1.apply("hello");
           //使用类名对实例方法进行方法引用
           Function<String,Integer> f1=String::length;
           Integer strLength = f1.apply("hello");
           System.out.println("length为"+strLength);//length为5
       
       
           //冗余写法
           //使用BiFunction处理可以传递两个参数的获取一个返回值的接口，实际上这里使用Function接口和BiFunction接口的区别就是
           //    使用类名调用实例方法本身就需要消耗一个参数作为方法调用的对象，如果需要传递参数就对接口中的抽象方法的参数列表有限制，
           //    此时就需要使用不同的接口，函数式接口一般都对抽象方法的参数类型和返回值类型做了泛型规范，所以一般在接口定义中就对参
           //    数个数进行了限制，所以这里如果把BiFunction改成Function就会报错
           //BiFunction<String,Integer,String> f2=(str, index)->str.substring(index);
       
           //方法引用
           BiFunction<String,Integer,String> f2=String::substring;
           String handleStr = f2.apply("HelloWorld", 3);
           System.out.println("处理后的String:"+handleStr);//处理后的String:loWorld
       
       }
       

   • ClassName::new 类名::new 引用类的构造器

     用类名::new的方式引用类的构造器，这种引用方式调用类的无参构造还是有参数构造主要看函数式接口的泛型数量和抽象方法的传参个数，暂时把抽象方法的参数列表看成对应构造方法的重载，参数列表就是对应构造器的参数列表

     • 实例

       xxxxxxxxxx
       public class TestLambda {
           @Test
           public void test04(){
               //无参数构造使用不需要传参但是有返回值的函数式接口，Supplier就是这样特征的函数式接口
               //冗余写法
               //Supplier<Person> supplier1=()->new Person();
               //构造器方法引用
               Supplier<Person> supplier1=Person::new ;
               supplier1.get();  //Person的无参数构造方法执行
       
               //有参数构造方法
               // 冗余写法
               BiFunction<String,Integer,Person> bif=(str,age)->new Person(str,age);
               Person user = bif.apply("张三", 25);  //Person的有参数构造方法执行
           }
       }
       class Person{
           private String name;
           private Integer age;
       
           public Person() {
               System.out.println("Person的无参数构造方法执行");
           }
       
           public Person(String name, Integer age) {
               System.out.println("Person的有参数构造方法执行");
               this.name = name;
               this.age = age;
           }
       
           public String getName() {
               return name;
           }
       
           public void setName(String name) {
               this.name = name;
           }
       
           public Integer getAge() {
               return age;
           }
       
           public void setAge(Integer age) {
               this.age = age;
           }
       
           @Override
           public String toString() {
               return "Person{" +
                       "name='" + name + '\'' +
                       ", age=" + age +
                       '}';
           }
       }
       

   • TypeName[]::new String[]::new 调用数组的构造器

     int[]和String[]也可以看做一个类

     • 实例

       xxxxxxxxxx
       //int[]::new   引用数组的构造器
       @Test
       public void test05(){
           //冗余写法
           //Function<Integer,int[]> f1=(length)->new int[length];
       
           //方法引用
           Function<Integer,int[]> f1=int[]::new;
           int[] arr = f1.apply(10);
           System.out.println(Arrays.toString(arr));
       }
       

        

集合的Stream流式操作

Stream流和IO流没有任何关系，流式思想类似于工厂车间的生产流水线，Stream不是一种数据结构，不保存数据，而是对数据进行加工处理，Stream可以看做是流水线上的一个工序，在流水线上通过多个工序让一个原材料加工成一个商品

一般的Stream流都是单线程的，效率不够高；还有并行的Stream流

1. 案例初体验

   • 实例

     xxxxxxxxxx
     //集合的初次体验
     @Test
     public void testFilter(){
         //准备一个集合，初始化数据
         ArrayList<String> userList = new ArrayList<>();
         Collections.addAll(userList,"张无忌","周芷若","赵敏","张三","张三丰");
     
         //传统的对集合元素依次进行下列操作，获取到姓张的，名字长度为3个字的，并打印这些数据
         ArrayList<String> zhangList = new ArrayList<>();
         for (String user:userList) {
             if (user.startsWith("张")) {
                 zhangList.add(user);
             }
         }
         ArrayList<String> threeList = new ArrayList<>();
         for (String user:zhangList) {
             if (user.length()==3) {
                 threeList.add(user);
             }
         }
         for (String user:threeList) {
             System.out.print(user);
         }
         System.out.println();
     
         //Stream流式操作,filter需要传参函数式接口Predicate的实现类
         userList.stream().filter((str)->str.startsWith("张")).filter((str->str.length()==3)).forEach(str-> System.out.print(str));
     }
     

      

获取Stream流

1. 通过Collection接口中的默认方法default Stream<E> stream()获取Stream流

   返回值是Stream类型

   Map接口和Collection接口没有什么关系，所以Map接口没有stream方法，Map接口可以通过map.keySet()方法得到key的set集合可以使用stream方法；

   map.value()方法可以得到所有value值并放入Collection集合中使用stream方法得到stream流

   map.entrySet()方法可以得到键值对的set集合也可以通过stream方法得到stream流

2. 通过Stream中的静态方法static<T> Stream<T> of(T... values)也可以获取流

   可变长度参数的本质是一个数组，

   • 实例

     xxxxxxxxxx
     Stream<String> stream=Stream.of("aa","bb","cc");
     //可变参数列表可以传入数组
     String[] strs={"aa","bb","cc"};
     Stream<String> stream2=Stream.of(strs);
     //基本数据类型的数组虽然写出来不会报错，但是Stream流会将整个数组看做一个元素进行操作，这样是会出问题的，实际应用不要写
     int[] arr={11,22,33};
     Stream<int[]> stream3=Stream.of(arr);
     

Stream流的API

根据返回结果Stream流的方法可以分为终结方法和非终结方法，区分标准就是非终结方法的返回值类型是Stream，而终结方法的返回值类型不是Stream，可能是long或者void；非终结方法也叫函数拼接方法，即返回值仍然是Stream本身，支持链式调用

1. Stream流的常用方法

   不是全部，更多方法参考API文档

   • long-->stream.count()

     • 作用：统计Stream流中元素的个数

     • 实例：

       xxxxxxxxxx
       //stream.count()
       @Test
       public void testStreamAPI4(){
           ArrayList<String> user = new ArrayList<>();
           Collections.addAll(user,"迪丽热巴","宋远桥","苏星河","老子","庄子","孙子");
           System.out.println(user.stream().count());
       }
       

   • void-->stream.forEach(Consumer<? super String> action)

     • 作用：遍历流中的数据，对流中的元素进行统一处理

     • 实例：

       xxxxxxxxxx
       //stream.forEach()
       @Test
       public void testStreamAPI3(){
           ArrayList<String> user = new ArrayList<>();
           Collections.addAll(user,"迪丽热巴","宋远桥","苏星河","老子","庄子","孙子");
           //得到流用流的forEach方法.println方法是类System.out中的静态方法，可以用方法引用
           user.stream().forEach(str-> System.out.println(str));
           //方法引用
           user.stream().forEach(System.out::println);
       }
       

   • Stream-->stream.filter(Perdicate perdicate)

     • 作用：过滤掉一些元素，返回符合过滤条件的数据

     • 实例：

       xxxxxxxxxx
       //stream.filter()
       //Stream<T> filter(Predicate<? super T> predicate);
       @Test
       public void testStreamAPI5(){
           ArrayList<String> user = new ArrayList<>();
           Collections.addAll(user,"迪丽热巴","宋远桥","苏星河","老子","庄子","孙子");
           //将名字长度为3个字的人过滤掉,必须要调用终结方法才能执行非终结方法
           user.stream().filter(str->str.length()!=3).forEach(System.out::println);
       }
       

   • Stream-->stream.limit(Integer count)

     • 作用：取用流中的前几个元素

     • 实例：

       xxxxxxxxxx
       //stream.limit(long maxSize)
       @Test
       public void testStreamAPI6(){
           ArrayList<String> user = new ArrayList<>();
           Collections.addAll(user,"迪丽热巴","宋远桥","苏星河","老子","庄子","孙子");
           //使用limit方法，参数是指定要保留前多少个数据
           user.stream().limit(3).forEach(System.out::print);//迪丽热巴宋远桥苏星河
       }
       

   • Stream-->stream.skip(Integer count)

     • 作用：跳过流中的前count个元素

     • 实例：

       xxxxxxxxxx
       //stream.skip()
       @Test
       public void testStreamAPI7(){
           ArrayList<String> user = new ArrayList<>();
           Collections.addAll(user,"迪丽热巴","宋远桥","苏星河","老子","庄子","孙子");
           //使用skip方法，参数是指定要跳过前多少个数据
           user.stream().skip(3).forEach(System.out::print);//老子庄子孙子
       }
       

   • Stream-->stream.map(Function function)

     • 作用：映射，功能是将流中的元素类型转换成另外一种类型，比如字符串转换成Integer类型，同时还可以返回原类型，但是修改了对应元素的属性

     • 备注说明：如果Function函数式接口实现是构造方法引用，会自动将元素作为参数调用有参数构造方法

     • 实例：

       xxxxxxxxxx
       //stream.map()
       @Test
       public void testStreamAPI8(){
           ArrayList<String> data = new ArrayList<>();
           Collections.addAll(data,"11","22","33");
           //使用map方法将String类型的元素转换成其他类型的元素，转换规则要在map的参数中的Function函数式接口中指定
           //<R> Stream<R> map(Function<? super T, ? extends R> mapper);
           data.stream().map(Integer::parseInt).forEach(System.out::print);//112233
       }
       

   • Stream-->stream.sorted()

     • 作用：无参sorted根据集合的自然顺序来排序，是字典序吗？

     • 实例：

       xxxxxxxxxx
       //stream.sorted(),根据自然序对元素进行排序
       @Test
       public void testStreamAPI9(){
           ArrayList<String> data = new ArrayList<>();
           Collections.addAll(data,"33","22","11","55");
           data.stream().sorted().forEach(System.out::print);//11223355
       }
       

   • Stream-->stream.sorted(Comparator<? super T> comparator)

     • 作用：根据比较器指定的规则排序，需要传参Comparator比较器

     • 实例：

       xxxxxxxxxx
       //stream.sorted(Comparator<?>),根据指定排序规则对元素进行排序
       //Comparator是函数式接口，只有一个抽象方法int compare(T o1, T o2);如果o1-O2就是升序，o2-o1就是降序
       @Test
       public void testStreamAPI10(){
           ArrayList<String> data = new ArrayList<>();
           Collections.addAll(data,"33","22","11","55");
           data.stream().
                   map(Integer::parseInt).
                   //sorted((Integer ele1,Integer ele2)->(ele2-ele1)).
                   //简写需要参数类型本身就是Integer或者能加减的类型,如果本身就是自然序，排序是不用写的，写了也不会生效
                   sorted((ele1,ele2)->(ele2-ele1)).
                   forEach(System.out::print);//55332211
       
       }
       

   • Stream-->stream.distinct()

     • 作用：去掉流中重复的数据

     • 备注说明：默认情况下是无法去掉自定义的重复数据类型，比如Person；distinct方法判断重复的依据是hashCode和equals方法，重写以后针对自定义类才有判断对象重复的依据

     • 实例：

       xxxxxxxxxx
       //stream.distinct()流中重复的数据只保留一份
       @Test
       public void testStreamAPI11(){
           //Stream<String> stream = Stream.of("11", "22", "33", "22", "33", "11");
           //stream.distinct().forEach(System.out::print);//112233
       
           //默认情况下重复的自定义类distinct方法不起效,需要重写自定义类的HashCode方法和equals方法
           Stream<Person> person = Stream.of(new Person("貂蝉", 16),
                   new Person("杨玉环",18),
                   new Person("杨玉环",18),
                   new Person("西施",20),
                   new Person("西施",20),
                   new Person("王昭君",22));
           person.distinct().forEach(System.out::println);
           // 没重写自定义类的hashCode和equals方法，无法对自定义类去重
           /**
            * Person{name='貂蝉', age=16}
            * Person{name='杨玉环', age=18}
            * Person{name='杨玉环', age=18}
            * Person{name='西施', age=20}
            * Person{name='西施', age=20}
            * Person{name='王昭君', age=22}
            * */
           //重写自定义类的hashCode和equals方法以后对自定义类去重
           /**
            * Person{name='貂蝉', age=16}
            * Person{name='杨玉环', age=18}
            * Person{name='西施', age=20}
            * Person{name='王昭君', age=22}
            * */
       }
       

   • Stream-->stream.allMatch(Pewdicate<? super I> predicate)

     • 作用：判断流中的元素是否全部满足指定条件，全部满足返回true，不全部满足返回false

     • 实例：

       xxxxxxxxxx
       //allMatch()检查流中的数据是否完全匹配
       @Test
       public void testAllMatch(){
           Stream<Integer> stream = Stream.of(5, 3, 6, 1);
           boolean result = stream.allMatch((Integer i) -> {
               return i > 0;
           });
           System.out.println(result);
       }
       

   • Stream-->stream.anyMatch(Pewdicate<? super I> predicate)

     • 作用：判断流中是否存在元素匹配指定条件，存在满足条件的元素返回true，不存在返回false

     • 实例：

       xxxxxxxxxx
       //anyMatch()检查流中的元素是否存在匹配指定条件,存在返回false，不存在返回false
       @Test
       public void testAnyMatch(){
           Stream<Integer> stream = Stream.of(5, 3, 6, 1);
           boolean result = stream.anyMatch(i -> i > 6);
           System.out.println(result);
       }
       

   • Stream-->stream.noneMatch(Pewdicate<? super I> predicate)

     • 作用：判断流中是否所有元素都不匹配指定条件，都不匹配返回true，存在元素匹配返回false

     • 实例：

       xxxxxxxxxx
       //noneMatch()检查流中的元素是否都不匹配指定条件，都不匹配返回true，存在至少一个匹配就返回false
       @Test
       public void testNoneMatch(){
           Stream<Integer> stream = Stream.of(5, 3, 6, 1);
           boolean result = stream.noneMatch(i -> i < 0);
           System.out.println(result);
       }
       

   • Optional<Integer>-->stream.findFirst()

     • 作用：找到流中的第一个元素

     • 备注说明：返回值类型Optional<Integer>，意思是该方法的结果可能找得到，也可能找不到，值需要使用option.get()方法获取；注意Optional<Integer>-->stream.findAny()的作用和findFirst()一样都是找到第一个元素

     • 实例：

       xxxxxxxxxx
       //findFirst()检查流中的元素是否都不匹配指定条件，都不匹配返回true，存在至少一个匹配就返回false
       @Test
       public void testFindFirst(){
           Stream<Integer> stream = Stream.of(5, 3, 6, 1);
           //Optional<Integer> firstElement = stream.findFirst();
           Optional<Integer> firstElement = stream.findAny();//findAny和findFirst找到的都是第一个元素
           System.out.println(firstElement.get());//5
       }
       

   • Optional<Integer>-->stream.max(Comparator<? super Integer> comparator)

     • 作用：找到流中值最大的元素

     • 备注说明：Comparator接口抽象方法o1-o2是升序【看成序号正常升就是升序】，配合Comparator接口其实可以实现单独使用max或者min方法同时获取最大值和最小值的需求

     • 实例：

       xxxxxxxxxx
       //max()获取到流中元素的最大值，比较规则通过实现Comparator接口来实现
       @Test
       public void testMax(){
           //o1-o2是元素按照升序排序
           Optional<Integer> max = Stream.of(5, 3, 6, 1).max((o1, o2) -> o1 - o2);
           System.out.println(max.get());
       }
       

   • Optional<Integer>-->stream.min(Comparator<? super Integer> comparator)

     • 作用：找到流中值最大的元素

     • 实例：

       xxxxxxxxxx
       //min()获取到流元素中按照指定顺序排序的最小值
       @Test
       public void testMin(){
           //Optional<Integer> min = Stream.of(5, 3, 6, 1).min((o1, o2) -> o1 - o2);
           //System.out.println(min.get());//1
           Optional<Integer> min = Stream.of(5, 3, 6, 1).min((o1, o2) -> o2 - o1);
           System.out.println(min.get());//6
       }
       

   • T-->stream.reduce(T identity,BinaryOperator<T> accumulator)

     • 作用：找到流中值最大的元素

     • 备注说明：Map方法和reduce方法组合使用能大大简化对集合的操作

       xxxxxxxxxx
       //reduce和map方法组合使用能大大简化集合开发
       @Test
       public void testMapReduce(){
           //数据
           Stream<Person> userList = Stream.of(
                   new Person("刘德华", 58),
                   new Person("张学友", 56),
                   new Person("郭富城", 54),
                   new Person("黎明", 52)
           );
           //求出所有年龄的总和:map得到年龄的流，对年龄求和
           Integer ageSum = userList.map(user -> user.getAge())
                   //可以使用Integer内部求和的静态方法Integer.sum
                   //.reduce(0, (x, y) -> x + y);
                   .reduce(0,Integer::sum);
           System.out.println("用户年龄总和:"+ageSum);
       
           //获取到年龄的最大值
           //流不能重复操作，以下对同一个流再次使用map方法会报错,再次使用map方法需要再次重新创建流
           //Optional<Integer> maxAge = userList.map(user -> user.getAge()).reduce((x, y) -> x > y ? x : y);
           Stream<Person> userList2 = Stream.of(
                   new Person("刘德华", 58),
                   new Person("张学友", 56),
                   new Person("郭富城", 54),
                   new Person("黎明", 52)
           );
           //哪个元素大返回哪个可以调用Math.max方法
           //Optional<Integer> maxAge = userList2.map(user -> user.getAge()).reduce((x, y) -> x > y ? x : y);
           Optional<Integer> maxAge = userList2.map(user -> user.getAge()).reduce(Math::max);
           System.out.println("maxAge:"+maxAge.get());
       
           //统计字符a出现的次数
           Integer count = Stream.of("a", "c", "b", "a", "b", "a").map(a -> a == "a" ? 1 : 0).reduce(0, Integer::sum);
           System.out.println("a字符出现的次数:"+count);
       }
       

     • 实例：

       xxxxxxxxxx
       //reduce()按照自定义的方式对流中的元素结合上次执行的结果自定义对元素进行操作
       @Test
       public void testReduce(){
           //T reduce(T identity, BinaryOperator<T> accumulator);
           //T identity:默认值
           //BinaryOperator<T> accumulator:自定义对数据处理的方式，BinaryOperator接口继承自BiFunction接口，里面只有静态方法，所以这个
           //函数式接口的抽象方法是继承的BiFunction的apply方法，这里对BinaryOperator<T>的实现其实是对BiFunction的apply方法的实现
           //这儿BinaryOperator<T>中的泛型是根据reduce方法传参类型自动确定的,这个泛型限制死了BiFunction的三个泛型类型都是reduce的第一个参数
           //的类型，即apply接口的两个参数和返回值需要和reduce的第一个参数的类型相同
           //可以看出，x是前一次reduce方法执行得到的结果，y是每次按顺序选中的流中的元素，如果指定了初始值，x一开始就为初始值，y为流中的第一个元素
           //如果没有指定初始值，x就以流中的第一个元素作为初始值，y以流中的第二个值作为初始值
           Integer result = Stream.of(4, 5, 3, 9).reduce(0, (x, y) -> {
               System.out.print("x="+x+",y="+y+";");//x=0,y=4;x=4,y=5;x=9,y=3;x=12,y=9;
               return x + y;
           });
           System.out.println(result);//21
       }
       

   • IntStream-->stream.mapToInt(ToIntFunction<? super T> mapper)

     • 作用：可以将Stream<Integer>中的Integer类型转换成int类型

     • 备注说明：使用包装类存在性能问题，Integer占用的内存比int多,Stream流在操作过程中自动装箱拆箱；除了mapToInt还有其他的mapToLong等其他方法可以将元素转成其他的基本数据类型；Stream、IntStream、LongStream都继承于BaseStream，区别就是IntStream相对于Stream操作的是基本数据类型而不是包装类

     • 实例：

       xxxxxxxxxx
       //mapToInt()能将Stream<Integer>类型的流转成基本数据类型int的流，减少自动装箱拆箱和内存开销
       @Test
       public void testNumericStream(){
           //Integer占用的内存比int多，在Stream流中操作会自动装箱拆箱
           //对于int类型的数据流会因为要使用泛型将int类型的数据自动装箱成Integer类型
           Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
           //把大于3的元素打印出来,对数据进行比较操作的时候也会自动拆箱
           stream.filter(n->n>3).forEach(System.out::println);
       
           //IntStream mapToInt(ToIntFunction<? super T> mapper);将stream流中的包装类Integer
           //IntStream内部操作的是int类型的数据，可以节省内存，减少自动装箱拆箱
           //通过Integer的实例方法intValue能够将Integer类型转成int类型，这样能减少自动装箱拆箱以及内存开销
           IntStream intStream = Stream.of(1, 2, 3, 4, 5).mapToInt(Integer::intValue);
           intStream.filter(n->n>3).forEach(System.out::println);
       }
       

   • Stream<T>-->Stream.concat(Stream<? extends T> a,Stream<? extends T> b)

     • 作用：将两个Stream流合并成一个stream流，是将两个流中的元素

     • 备注说明：被合并的两个stream流的元素类型是相同的，合并后的stream流的元素类型也是一样的；参与合并的流或者中间流不能使用forEach方法，会提示非法状态错误页

     • 实例：

       xxxxxxxxxx
       //concat()方法能将两个流合并成一个流，合并是合并流中的元素到一个流中
       @Test
       public void testConcat(){
           Stream<String> stream1 = Stream.of("张三","王五");
           Stream<String> stream2 = Stream.of("李四","王五");
           //这种合并方式只支持两个流合并，不支持三个及以上的流合并；同时合并以后不能操作之前的流，合并过程中有相同的元素也会完全保留到新流中
           //但是可以多次合并，被合并的流和中间流不能进行其他流式操作，否则会抛非法状态异常;我这里对流使用了forEach会显示已经用过，
           //猜测是因为合并过程需要使用forEach所以会提示重复，不知道其他方法是否能使用，有应用场景试一下
           Stream<String> newStream = Stream.concat(stream1, stream2);
           //newStream.forEach(System.out::println);
           Stream<String> stream3 = Stream.of("赵六", "王五");
           Stream<String> newStream2 = Stream.concat(newStream, stream3);
           newStream2.forEach(System.out::println);
       }
       

2. Stream流的注意事项

   • 对一个Stream流的方法只能操作一次，重复相同操作会抛非法状态异常，如下所示这种情况就就会抛异常

     xxxxxxxxxx
     Stream<String> stream =Stream.of("aa","bb","cc");
     //以下两步第二步就会报错，提示流已经关闭或者已经操作过
     long count=stream.count();
     long count2=stream.count();
     

   • Stream流的非终结方法返回的流是新的流，两个流不是同一个对象

     xxxxxxxxxx
     //Stream方法返回的是新的流
     @Test
     public void testStreamAPI(){
         Stream<String> stream = Stream.of("aa", "bb", "cc");
         Stream<String> limit = stream.limit(1);
                         System.out.println("stream"+stream);//streamjava.util.stream.ReferencePipeline$Head@25618e91
         System.out.println("limit" + limit);//limitjava.util.stream.SliceOps$1@7a92922
     }
     

   • Stream不调用终结方法，中间的非终结操作是不会执行的

     xxxxxxxxxx
     //Stream方法不调用终结方法，中间的方法操作是不会执行的
     @Test
     public void testStreamAPI2(){
         Stream<String> stream = Stream.of("aa", "bb", "cc");
         //不写终结方法，非终结方法是不会执行的
         //stream.filter((str)->{
         //    System.out.println(str);
         //    return true;
         //});
         //写了终结方法，非终结方法才会执行
         stream.filter((str)->{
             System.out.print(str);//aabbcc
             return true;
         }).count();
     }
     

      

Stream流的数据处理

收集数据

在流操作完成后，可以将Stream流的元素放到集合或者数组中，可以收集流中的数据

1. 将流中的数据收集到集合中

   • 实例

     xxxxxxxxxx
     //将流中的数据收集到集合中
     @Test
     public void testCollect(){
         Stream<String> stream = Stream.of("aa", "bb", "cc", "bb");
         //1.将流中的数据收集到list集合中，
         //List<String> list = stream.collect(Collectors.toList());
         //System.out.println("list:"+list);
     
         //2.将流中的数据收集到set集合中
         //Set<String> set = stream.collect(Collectors.toSet());
         //System.out.println("set:"+set);
     
         //3. 将流中的数据收集到ArrayList集合中
         ArrayList<String> arrayList = stream.collect(Collectors.toCollection(ArrayList::new));
         System.out.println("arrayList:"+arrayList);
     
         //4. 将流中的数据搜集到,set集合和HashSet集合会自动去掉重复的数据
         //HashSet<String> hashSet = stream.collect(Collectors.toCollection(HashSet::new));
         //System.out.println("HashSet:"+hashSet);
     
     }
     //5. 将流中的数据搜集到Map集合中
     public Map<Long, String> getIdNameMap(List<Account> accounts) {
         return
     accounts.stream().collect(Collectors.toMap(Account::getId, Account::getUsername)); 
     }
     

2. 将流中的数据搜集到数组中

   • 实例

     xxxxxxxxxx
     //将流中的数据搜集到数组中
     @Test
     public void testStreamToArray(){
         Stream<String> stream = Stream.of("aa", "bb", "cc", "bb");
         //1.将流中的数据转成Object数组,Object数组不是很方便，比如想使用String的length方法还需要向下强转为String才能执行相关操作
         //Object[] objects = stream.toArray();
         //for (Object o:objects) {
         //    System.out.print("Objects:"+o+",");
         //}
     
         //2.将流中的数据转成指定类型的数组
         String[] strings = stream.toArray(String[]::new);
         for (String str:strings) {
             System.out.print("String:"+str+"|"+str.length()+",");
         }
     }
     

      

数据聚合计算

聚合计算和数据库的对字段操作是一样的，如获取最大值、最小值、求总和、平均值、统计数量

获取最大值调用max方法也能单独实现，这里面的操作基本直接调用Stream本身的API就能实现

1. API

   • 实例

     xxxxxxxxxx
     @Test
     public void testAggregateFunction(){
         Stream<Student> studentStream = Stream.of(
                 new Student("赵丽颖", 58, 95),
                 new Student("杨颖", 56, 88),
                 new Student("迪丽热巴", 56, 99),
                 new Student("柳岩", 52, 77)
         );
         //1. 获取某个属性最大值的对应元素，max函数返回的也是元素
         //max函数
         //Optional<Student> max = studentStream.max((student1, student2) -> student1.getScore() - student2.getScore());
         //System.out.println("最高成绩学生:"+max.get());
         //聚合函数Collectors.maxBy(),竟然不能和max函数合用,貌似一个流不能被多次操作，先后maxBy和minBy都会出错
         //Optional<Student> maxScoreStudent = studentStream.collect(Collectors.maxBy((student1, student2) -> student1.getScore() - student2.getScore()));
         //System.out.println("最高成绩学生:"+maxScoreStudent.get());
     
         //2.获取某个属性最小值的对应元素
         //Optional<Student> minScoreStudent = studentStream.collect(Collectors.minBy((student1, student2) -> student1.getScore() - student2.getScore()));
         //System.out.println("最低成绩学生:"+minScoreStudent.get());
     
         //3.将元素的属性求和
         //求和是summingInt函数实现的，该函数的传参是函数式接口ToIntFunction的匿名内部类，作用是获取要求和的属性值并将其转换为int基本类型
         //Integer sum = studentStream.collect(Collectors.summingInt(s -> s.getAge()));
         //System.out.println("学员年龄总和:"+sum);
     
         //4,将元素的属性值求平均值，
         //averagingInt的传参依然是一个函数式接口ToIntFunction的匿名内部类,注意传参int类型，返回值是Double类型
         //Double averageScore = studentStream.collect(Collectors.averagingInt(s -> s.getScore()));
         //自定义类也可以使用方法引用,这里是通过类名引用实例方法
         //Double averageScore = studentStream.collect(Collectors.averagingInt(Student::getScore));
         //System.out.println("学员平均成绩:"+averageScore);
     
         //5. 统计流中元素的数量 ，用count方法也能统计流中元素的数量
         Long count = studentStream.collect(Collectors.counting());
         System.out.println("流中元素的数量:"+count);
     }
     

      

数据分组

1. 分组API

   • 对流中的数据根据某个标准进行一级分组

     xxxxxxxxxx
     @Test
     public void testGroup(){
         Stream<Student> studentStream = Stream.of(
                 new Student("赵丽颖", 52, 95),
                 new Student("杨颖", 56, 88),
                 new Student("迪丽热巴", 56, 40),
                 new Student("柳岩", 52, 50)
         );
         //groupingBy需要的参数是函数式接口Function[传入一个参数经过加工返回一个参数]，参数是分类的依据
         //这个地方很奇妙，返回值即分组的依据不一定是元素的某个属性，感觉更像对每个元素进行进行处理的过程中调用函数式接口的实现类并将元素
         //归类为对应的函数式接口Function的apply函数返回值
         Map<Integer, List<Student>> groupByAge = studentStream.collect(Collectors.groupingBy((student) -> student.getAge()));
         System.out.println(groupByAge);//{52=[Student{name='赵丽颖', age=52, score=95}, Student{name='柳岩', age=52, score=50}], 56=[Student{name='杨颖', age=56, score=88}, Student{name='迪丽热巴', age=56, score=40}]}
         //Map<String, List<Student>> groupByScore = studentStream.collect(Collectors.groupingBy(student -> student.getScore() >= 60 ? "及格" : "不及格"));
         //返回的是一个Map，key是分类的依据；value是对应元素的List集合
         //System.out.println(groupByScore);//{不及格=[Student{name='迪丽热巴', age=56, score=40}, Student{name='柳岩', age=52, score=50}], 及格=[Student{name='赵丽颖', age=52, score=95}, Student{name='杨颖', age=56, score=88}]}
     }
     

   • 对流中的数据进行多级分组

     逻辑是先针对某个标准进行分组，再在同一个分组中根据另外一个标准再次进行分组；使用的是groupingBy的重载方法，参数列表是Function接口和Collector接口的groupingBy单参方法的返回值【同样需要指定Function接口的匿名实现，即返回第二级分组标准】；Function是第一级分类的标准，Collector是第二级分类的标准

     返回的仍然是一个map，map的key是第一层的分类标准；map的value仍然是一个Map，是二级分类

     xxxxxxxxxx
     @Test
     public void testMultiLevelGroup(){
         Stream<Student> studentStream = Stream.of(
                 new Student("赵丽颖", 52, 95),
                 new Student("杨颖", 56, 88),
                 new Student("迪丽热巴", 56, 40),
                 new Student("柳岩", 52, 50)
         );
         /**public static <T, K, A, D>
             Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                                   Collector<? super T, A, D> downstream) {
                 return groupingBy(classifier, HashMap::new, downstream);
             }
          第一个参数是Function接口指定一级分类的标准，第二个参数是一个Collector，一般是Collectors.groupingBy()的单参方法
          并重写Function接口即指定二级分类标准
          */
         Map<Integer, Map<String, List<Student>>> studentGroupMultiLevel = studentStream.collect(Collectors.groupingBy(student -> student.getAge(), Collectors.groupingBy(student -> student.getScore() >= 60 ? "及格" : "不及格")));
         //Map是重写了toString方法的，可以直接打印
         System.out.println(studentGroupMultiLevel);
         /**
          * {52={
          *      不及格=[Student{name='柳岩', age=52, score=50}], 
          *      及格=[Student{name='赵丽颖', age=52, score=95}]
          *      }, 
          * 56={
          *      不及格=[Student{name='迪丽热巴', age=56, score=40}], 
          *      及格=[Student{name='杨颖', age=56, score=88}]
          *      }
          * }
          * */
     }
     

      

数据分区

数据分区和数据分组类似，但是数据分区只能分成true和false两个组，数据分组可以分成多个组且还能多级分组

1. API

   • 实例

     xxxxxxxxxx
     @Test//测试数据分区
     public void testPartition(){
         Stream<Student> studentStream = Stream.of(
                 new Student("赵丽颖", 52, 95),
                 new Student("杨颖", 56, 88),
                 new Student("迪丽热巴", 56, 40),
                 new Student("柳岩", 52, 50)
         );
         //partitioningBy的参数类型是函数式接口Predicate，意味着分区key只能是true和false
         Map<Boolean, List<Student>> scorePartition = studentStream.collect(Collectors.partitioningBy(student -> student.getScore() >= 60));
         System.out.println(scorePartition);
         /**
          *
          {
             false=[Student{name='迪丽热巴', age=56, score=40}, Student{name='柳岩', age=52, score=50}],
             true=[Student{name='赵丽颖', age=52, score=95}, Student{name='杨颖', age=56, score=88}]
          }
          */
     }
     

数据拼接

将String类型的数据根据指定规则进行字符串拼接

1. 数据间拼接一个指定间隔字符串

   • 实例

     xxxxxxxxxx
     @Test//测试数据拼接
     public void testJoining(){
         Stream<Student> studentStream = Stream.of(
                 new Student("赵丽颖", 52, 95),
                 new Student("杨颖", 56, 88),
                 new Student("迪丽热巴", 56, 40),
                 new Student("柳岩", 52, 50)
         );
         //1. 数据之间拼接一个间隔字符串，返回一个字符串
         //joining(CharSequence delimiter)
         //String studentName = studentStream.map(Student::getName).collect(Collectors.joining(" | "));
         //System.out.println(studentName);//赵丽颖 | 杨颖 | 迪丽热巴 | 柳岩
     
         //2. 数据之间拼接一个间隔字符串，首尾加前缀后缀
         String studentName = studentStream.map(Student::getName).collect(Collectors.joining(" | ", "前缀", "后缀"));
         System.out.println(studentName);//前缀赵丽颖 | 杨颖 | 迪丽热巴 | 柳岩后缀
     }
     

      

并行Stream流

上述的Stream流都是串行Stream流，效率低

1. 串行Stream流

   对每个元素的处理都使用的同一个线程

   xxxxxxxxxx
   //串行Stream流
   @Test
   public void testStreamThread(){
       Stream.of(4,5,3,9,1,2,6).filter(data->{
           System.out.println(Thread.currentThread()+" | "+data+","+data.getClass());
           /**
            * Thread[main,5,main] | 4,class java.lang.Integer
            * Thread[main,5,main] | 5,class java.lang.Integer
            * Thread[main,5,main] | 3,class java.lang.Integer
            * Thread[main,5,main] | 9,class java.lang.Integer
            * Thread[main,5,main] | 1,class java.lang.Integer
            * Thread[main,5,main] | 2,class java.lang.Integer
            * Thread[main,5,main] | 6,class java.lang.Integer
            * 串行Stream流对每个元素的处理都使用的同一个线程
            * */
           return data>3;
       }).count();
   }
   

2. 获取并行流的两种方式

   • 方式一：直接通过list集合中的实例方法parallelStream方法获取并行流，list.parallelStream()

   • 方式二：通过串行stream流的实例方法stream.parallelStream()获取对应的并行流

   • 实例

     xxxxxxxxxx
     //获取并行Stream流
     @Test
     public void testParallelStream(){
         //1. 方式一:直接通过list集合的实例方法获取并行Stream流
         ArrayList<String> list = new ArrayList<>();
         //并行stream流应该也是Stream的子实现类
         Stream<String> stream = list.parallelStream();
     
         //2. 方式二:将串行流转成并行流,串行流中的parallel()方法返回的就是并行流
         Stream<String> parallel = list.stream().parallel();
     }
     

3. 并行Stream流

   并行流的不同元素处理使用的是不同的线程

   xxxxxxxxxx
   //并行Stream流
   @Test
   public void testStreamThreadParallel(){
       Stream.of(4,5,3,9,1,2,6).parallel().filter(data->{
           System.out.println(Thread.currentThread()+" | "+data+","+data.getClass());
           /**
            * Thread[main,5,main] | 1,class java.lang.Integer
            * Thread[ForkJoinPool.commonPool-worker-1,5,main] | 5,class java.lang.Integer
            * Thread[ForkJoinPool.commonPool-worker-6,5,main] | 3,class java.lang.Integer
            * Thread[ForkJoinPool.commonPool-worker-5,5,main] | 2,class java.lang.Integer
            * Thread[ForkJoinPool.commonPool-worker-4,5,main] | 9,class java.lang.Integer
            * Thread[ForkJoinPool.commonPool-worker-3,5,main] | 6,class java.lang.Integer
            * Thread[ForkJoinPool.commonPool-worker-2,5,main] | 4,class java.lang.Integer
            * 并行Stream流对每个元素的处理都使用的不同的线程
            * */
           return data>3;
       }).count();
   }
   

4. 并行stream流的效率

   xxxxxxxxxx
   //作为测试的开始时间
   long start;
   //测试stream和并行stream的效率,设置循环次数相加操作消耗的时间，设置循环相加5亿次
   long times=500000000;
   
   @Before//@Before注解是junit自带的注解，会在测试程序运行前先执行
   public void init(){
       start=System.currentTimeMillis();
   }
   
   @After//@After也是junit自带的注解，会在测试程序运行后执行
   public void after(){
       long end=System.currentTimeMillis();
       System.out.println("消耗时间:"+(end-start)+"ms");
   }
   
   @Test//单纯的5亿次相加运算   消耗时间:162ms
   public void testEfficiencyLocal(){
       int sum=0;
       for (int i = 0; i < times; i++) {
           sum+=i;
       }
   }
   
   @Test//串行stream流的5亿次相加操作    消耗时间:771ms
   public void testEfficiencyStream(){
       //LongStream.rangeClosed(0,times)是得到0到指定值之间的整数Long类型的流，这里的流有五亿个元素
       LongStream.rangeClosed(0,times).reduce(0,Long::sum);
   }
   
   @Test//并行stream流的5亿次相加操作     消耗时间:50ms
   //并行的stream流会采用分治算法将大任务切分成多个小任务，每个小任务分配到独立的线程上运行，并行Stream流的效率是最高的，且远超串行stream流
   public void testEfficiencyParallelStream(){
       LongStream.rangeClosed(0,times).parallel().reduce(0,Long::sum);
   }
   

5. 多线程操作可能存在线程安全问题

   一般的解决方法有给涉及线程安全的操作加锁放在同步代码块中，使用线程安全的集合，或者调用Stream接口的toArray或者collect方法【返回集合或者数组】对数据的操作就是线程安全的

   xxxxxxxxxx
   //并行stream的线程安全问题,多线程操作下对不安全的ArrayList集合执行添加或者修改操作，可能由于两个线程同时对集合操作，导致集合数据丢失
   @Test
   public void testParallelStreamSecurity(){
       ArrayList<Integer> list = new ArrayList<>();
       //IntStream.rangeClosed(1,1000).parallel().forEach(i->list.add(i));
       //System.out.println("list集合的容量大小:"+list.size());//list集合的容量大小:980 7ms
   
       //1. 线程安全方案1：使用同步代码块用类锁锁代码执行
       //Object obj = new Object();
       //IntStream.rangeClosed(1,1000).parallel().forEach(i->{
       //    synchronized (obj){
       //        list.add(i);
       //    }
       //});
       //System.out.println("list集合的容量大小:"+list.size());//list集合的容量大小:1000   消耗时间:7ms
   
       //2. 线程安全方案2：ArrayList是线程不安全的，使用Vector线程安全的集合，
       //Vector<Integer> vector = new Vector();
       //IntStream.rangeClosed(1,1000).parallel().forEach(i->vector.add(i));
       //System.out.println("vector集合的容量大小:"+vector.size());//vector集合的容量大小:1000  消耗时间:8ms
       //也可以使用api：Collections.synchronizedList(list)把线程不安全的集合变成线程安全的集合
       //List<Integer> synchronizedList = Collections.synchronizedList(list);
       //IntStream.rangeClosed(1,1000).parallel().forEach(i->synchronizedList.add(i));
       //System.out.println("synchronizedList:"+synchronizedList.size());//synchronizedList:1000  消耗时间:8ms
   
       //3. 线程安全方案3，调用Stream流的collect/toArray方法收集流中的数据到list集合中也是线程安全的
       //IntStream调用collect方法传参比较复杂，先执行boxed方法就可以获取Integer类型的Stream流，此时调用collect方法只需要按照固定写法
       List<Integer> collect = IntStream.rangeClosed(1, 1000).parallel().boxed().collect(Collectors.toList());
       System.out.println("collect:"+collect.size());
   }
   

6. 并行Stream流的实现原理

   • parallelStream是基于Fork/Join框架实现的

     parallelStream底层使用的不是普通的线程，使用的是Fork/Join框架;Fork/Join是JDK7引入的新的线程框架，作用是可以将一个大任务拆分成很多小任务来异步执行

   • Fork/Join框架主要包含三个模块

     • 线程池：ForkJoinPool，继承自Executor，是线程池

     • 任务对象：ForkJoinTask，表示拆分出来的小任务，实现了Future和Serializable接口，实际使用是自定义任务类继承ForkJoinTask的子类

     • 执行任务的线程对象：ForkJoinWorkerThread，继承于Thread

   • Fork/Join框架的原理

     • Fork/Join框架使用分治算法来将大任务拆分成小任务，比如排序将1000w个数分为两个500w个数的排序任务，再对500w个数的排序任务再分割，直到最后的排序任务个数达到一定的阈值才会使用其他排序方法局部排序，排序完成以后对局部有序的结果再合并，Fork是大任务拆分成小任务的过程，Join是小任务合并为大任务的过程

   • 工作窃取算法

     • Fork/Join最核心的地方是利用现代硬件设备多核，利用空闲的CPU提高性能，工作窃取算法的作用是某个线程从其他队列中窃取任务来执行，某个线程把任务执行完空闲以后去别的线程窃取排队最后的任务来执行

   • Fork/Join框架实例

     • 一个计算1-10000的任务，先对任务进行拆分，加法运算的数量大于3000就拆分任务，小于3000就进行运算

       在计算次数较少的情况下，比如1000w次相加，仍然是直接用单线程循环遍历相加会快一些，任务管理器--CPU--图形右键--将图形更改为--逻辑处理器，可以查看CPU的线程占用率；Fork/Join执行任务会所有的CPU线程都打满，而单线程遍历运算只会拉起一个CPU线程的占用率

     • 代码实现

       【求和任务类】

       xxxxxxxxxx
       class SumRecursiveTask extends RecursiveTask<Long>{
       
           //定义计算任务不再拆分的阈值
           private static final long THRESHOLD=3000L;
           //定义计算任务的初始值
           private final long start;
           //定义计算任务的结束值
           private final long end;
       
           public SumRecursiveTask(long start,long end){
               this.start=start;
               this.end=end;
           }
       
           @Override
           protected Long compute() {
               //两个数一次计算
               long length=end-start;
               if(length<=THRESHOLD){
                   //任务不用拆分可以直接计算
                   long sum=0;
                   for (long i = start; i <=end ; i++) {
                       sum+=i;
                   }
                   //System.out.println("计算:"+start+"->"+end+"结果为:"+sum);
                   return sum;
               }else{
                   //数量大于拆分的阈值，任务继续拆分
                   long middle=(start+end)/2;
                   //System.out.println("任务拆分:左"+start+"->"+middle+",右:"+(middle+1)+"->"+end);
                   SumRecursiveTask leftTask = new SumRecursiveTask(start, middle);
                   leftTask.fork();
                   SumRecursiveTask rightTask = new SumRecursiveTask(middle + 1, end);
                   rightTask.fork();
                   return leftTask.join()+rightTask.join();
               }
           }
       }
       

       【代码执行效果】

       xxxxxxxxxx
       public class TestStream{    
           //测试ForkJoin框架实现任务拆分和多线程并行执行各个任务
           /**
            * 执行效果：
            *      任务拆分:左1->5000,右:5001->10000
            *      任务拆分:左1->2500,右:2501->5000
            *      任务拆分:左5001->7500,右:7501->10000
            *      计算:2501->5000结果为:9376250
            *      计算:5001->7500结果为:15626250
            *      计算:7501->10000结果为:21876250
            *      计算:1->2500结果为:3126250
            *      1->10000两两相加的结果为:50005000
            * */
           @Test
           public void testForkJoin(){
               //创建线程池对象
               ForkJoinPool forkJoinPool = new ForkJoinPool();
               //创建能拆分计算任务的任务类
               SumRecursiveTask sumRecursiveTask = new SumRecursiveTask(1, 10000000L);
               //线程池对象通过invoke方法执行任务类
               Long result = forkJoinPool.invoke(sumRecursiveTask);
               //System.out.println("1->10000两两相加的结果为:"+result);
               System.out.println(result);
           }
       
           @Test//这个不拆分竟然比拆分多线程计算快，而且数据量越大快的越多，离谱;1000w的计算量直接单线程循环比Fork/Join快，而且快的多，前者只需要3ms，后者需要116毫秒
           //后来相加运算设置成100000000000L，不拆分单线程需要二十多秒，但是拆分多线程只需要8秒
           public void test(){
               long sum=0;
               for (long i = 1; i <= 10000000L; i++) {
                   sum+=i;
               }
               System.out.println(sum);
           }
       }
       

   • 小结

     • 并行stream流parallelStream是线程不安全的，适用于CPU密集型场景，主要目的还是不要浪费CPU的性能，如果CPU本身就负载很大了还使用并行流，并不能起到很明显的效果，还可能影响其他程序的执行

     • 一般并行Stream流不适用于I/O密集型操作【磁盘I/O、网络I/O都属于I/O操作】，I/O操作一般不依赖CPU，使用并行流进行大批量的消息推送涉及大量I/O，反而会导致使用并行流更慢

     • 并行流使用时无法保证元素的顺序，即使用集合同步流数据即使保证了元素都正确也无法保证不同线程将指定元素按照顺序放在一个集合中

接口增强

1. 增强点

   • JDK8以前的接口只能放静态常量和抽象方法，JDK8对接口进行增强，还可以放默认方法和静态方法

   • JDK8接口

     xxxxxxxxxx
     interface 接口名{
         静态常量;
         抽象方法;
         默认方法;
         静态方法;
     }
     

2. 增强原因

   • 默认方法

     • 接口中只有抽象方法，接口新增抽象方法，所有的实现类都必须重写该抽象方法，不利于接口的扩展

     • 接口中的默认方法实现类不需要重写就可以直接进行使用，实现类也可以根据需要进行重写

       方便接口的扩展

       默认方法在实现类中重写不需要default关键字

     • 默认方法语法格式

       默认方法有方法体，与类中一般方法的定义相比只是多了一个default关键字

       xxxxxxxxxx
       interface 接口名{
           修饰符 default 返回值类型 方法名(){
               方法体;
           }
       }
       

   • 静态方法

     • 静态方法不能被实现类直接调用，也不能被实现类重写，只能通过接口名.方法名()进行调用

     • 静态方法语法格式

       与默认方法相比只是关键字default改成了static

       xxxxxxxxxx
       interface 接口名{
           修饰符 static 返回值类型 方法名(){
               方法体;
           }
       }
       

3. 默认方法和静态方法的区别

   • 默认方法必须通过实例调用，静态方法通过接口名调用

   • 默认方法可以被实现类继承，实现类可以直接使用接口定义的默认方法，也可以重写接口中的默认方法；静态方法不能被继承也不能被实现类重写，只能通过接口名进行调用

   • 接口中的方法需要被实现类继承或重写，使用默认方法；不需要被继承或者重写就直接使用静态方法

Optional类

Optional类只有两种状态，没有子类，一般看成一个容器，要么Optional中有值，要么就是null；主要作用是避免空指针检查，防止NullPointerException，结合方法orElse，ifPresent，ifPresentOrElse，map能够写出优雅的判空处理代码

1. 传统对指针判空的处理方式

   • 实例

     xxxxxxxxxx
     @Test//传统对指定判空处理的方式
     public void testTraditionalHandleNull(){
         String userName="zhangSan";
         //对引用判空进行处理
         if(userName!=null){
             System.out.println("用户姓名:"+userName);
         }else{
             System.out.println("姓名不存在");
         }
     }
     

2. Optional类的API

   • Optional<T> --> Optional.of(T t)

     • 作用：创建一个Optional对象，of方法只能传入具体值，不能传入null，传入null会报空指针异常

   • Optional<T> --> Optional.ofNullable(T t)

     • 作用：创建一个Optional对象，ofNullable方法既能传入具体值，也能传入null

   • Optional<T> --> Optional.empty()

     • 作用：创建一个内容为null的Optional对象

   • boolean --> optional.isPresent()

     • 作用：判断optional中是否有具体值，有具体值就返回true，如果没有值或者值为null就返回false

   • T t-->optional.get()

     • 作用：获取optional中的具体值，如果optional有具体值就返回具体值，没有值或者为null就会抛没有这个元素的异常；所以一般操作都使用optional.isPresent()对是否有值进行判断再决定是否取值进行处理

   • Optional --> optional.map(Function<T> function)

     • 作用：//TODO，课上没讲但是在对用户名字转大写案例中使用了，很好用，功能和Stream流的map方法类似，看文档研究研究

3. 使用Optional类对可能存在空值的情况处理

   • 使用apioptional.isPresent()来判断是否空值进一步处理

     xxxxxxxxxx
     @Test//使用Optional对可能存在空值的情况的处理
     public void testHandleNull(){
         Optional<Object> op1 = Optional.empty();
         Optional<String> op2 = Optional.ofNullable("张三");
         if(op2.isPresent()){
             System.out.println(op2.get());
         }else{
             System.out.println("没有值");
         }
     }
     

   • T --> optional.orElse(T t)

     • 作用：如果optional中有值就返回该具体值，如果optional中没有值就使用传参作为返回值

     • 实例：

       xxxxxxxxxx
       @Test//测试orElse方法使用默认值
       public void testOrElse(){
           Optional<String> userName = Optional.ofNullable("张三");//张三
           //Optional<String> userName = Optional.ofNullable(null);//没有值
           String user = userName.orElse("没有值");
           System.out.println(user);
       }
       

   • void --> optional.ifPresent(Comsumer<T> comsumer)

     • 作用：如果optional中有具体值就执行函数式接口Consumer的匿名实现，ifPresent方法自动传参optional中的具体值，如果optional中没有值就会什么也不做

     • 实例：

       xxxxxxxxxx
       @Test//测试IfPresent方法使用接口对判空进行处理
       //optional有值就执行函数式接口Consumer的实现，没有值就啥都不做
       public void testIfPresent(){
           Optional<String> userName = Optional.ofNullable("张三");//有值，值为:张三
           //Optional<Object> userName = Optional.ofNullable(null);
           //public void ifPresent(Consumer<? super T> action) {  传参Comsumer函数式接口
           //ifPresent的意思是如果有值就调用Consumer接口使用参数，会自动传参optional的具体值；没有值会啥事都不发生
           userName.ifPresent(user->{
               System.out.println("有值，值为:"+user);
           });
       }
       

   • void --> optional.ifPresentOrElse(Consumer<T> comsumer,Runnable runnable)

     • 作用：optional对象中存在具体值调用Consumer接口，没有值就执行Runnable接口的匿名实现

     • 实例：

       xxxxxxxxxx
       @Test//测试ifPresentOrElse方法使用接口对判空后进行处理
       public void testIfPresentOrElse(){
           //Optional<String> userName = Optional.ofNullable("张三");//有值，值为:张三
           Optional<String> userName = Optional.ofNullable(null);//没有值
           //public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
           //Consumer接口是判定optional有值以后对值处理的接口，Runnable接口是判定optional没有值以后的处理接口，Runnable接口就是一个空参的run方法
           userName.ifPresentOrElse(user-> System.out.println("有值，值为:"+user),
                   ()-> System.out.println("没有值"));
       
       }
       

4. 需求实现：将用户的名字属性全部转换成大写

   java中的toUpperCase会直接将中文原样输出

   xxxxxxxxxx
   @Test//用optional优雅实现对用户的某个属性判空和后续操作，如果名字属性不为空就统一转换大写
   public void testOptionalCase(){
       //Person user = new Person(null, 26);//null
       Person user = new Person("Mike", 26);//MIKE
       //将user对象封装成Optional对象
       Optional<Person> optionalData = Optional.of(user);
       //使用传统判空方式实现
       String upperUserNameTraditional = getUpperUserNameTraditional(user);
       System.out.println(upperUserNameTraditional);
       //使用Optional方式实现
       String upperUserNameOptional = getUpperUserNameOptional(optionalData);
       System.out.println(upperUserNameOptional);
   }
   
   //使用Optional对判空进行处理
   public String getUpperUserNameOptional(Optional<Person> optional){
       //optional也有map方法，作用似乎和stream流中的map方法一致，这个是链式处理完以后判断最终结果是否为空，不是原样输出，是就返回字符串null
       String userUpperName = optional.map(person -> person.getName()).
               map(userName -> userName.toUpperCase()).
               orElse("null");
       return userUpperName;
   }
   
   //传统方式对判空进行处理,首先要保证person不为空，然后保证person中的name属性不为空
   public String getUpperUserNameTraditional(Person person){
       if(person!=null){
           String userName = person.getName();
           if (userName!=null) {
               return userName.toUpperCase();
           }else{
               return "null";
           }
       }else{
           return "null";
       }
   }